package com.lizicloud.infrastructure.common.utils;

import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 * 集合操作工具类
 */
public class CollectionUtils {
    
    /**
     * 检查集合是否为空
     */
    public static boolean isEmpty(Collection<?> collection) {
        return collection == null || collection.isEmpty();
    }
    
    /**
     * 检查集合是否不为空
     */
    public static boolean isNotEmpty(Collection<?> collection) {
        return !isEmpty(collection);
    }
    
    /**
     * 检查Map是否为空
     */
    public static boolean isEmpty(Map<?, ?> map) {
        return map == null || map.isEmpty();
    }
    
    /**
     * 检查Map是否不为空
     */
    public static boolean isNotEmpty(Map<?, ?> map) {
        return !isEmpty(map);
    }
    
    /**
     * 创建ArrayList
     */
    public static <T> List<T> newArrayList() {
        return new ArrayList<>();
    }
    
    /**
     * 创建ArrayList（带初始元素）
     */
    @SafeVarargs
    public static <T> List<T> newArrayList(T... elements) {
        List<T> list = new ArrayList<>();
        if (elements != null) {
            Collections.addAll(list, elements);
        }
        return list;
    }
    
    /**
     * 创建HashMap
     */
    public static <K, V> Map<K, V> newHashMap() {
        return new HashMap<>();
    }
    
    /**
     * 创建HashMap（带初始容量）
     */
    public static <K, V> Map<K, V> newHashMap(int initialCapacity) {
        return new HashMap<>(initialCapacity);
    }
    
    /**
     * 创建HashSet
     */
    public static <T> Set<T> newHashSet() {
        return new HashSet<>();
    }
    
    /**
     * 创建HashSet（带初始元素）
     */
    @SafeVarargs
    public static <T> Set<T> newHashSet(T... elements) {
        Set<T> set = new HashSet<>();
        if (elements != null) {
            Collections.addAll(set, elements);
        }
        return set;
    }
    
    /**
     * 将数组转换为List
     */
    public static <T> List<T> asList(T[] array) {
        if (array == null) {
            return new ArrayList<>();
        }
        return Arrays.asList(array);
    }
    
    /**
     * 将List转换为Set
     */
    public static <T> Set<T> toSet(List<T> list) {
        if (list == null) {
            return new HashSet<>();
        }
        return new HashSet<>(list);
    }
    
    /**
     * 将Set转换为List
     */
    public static <T> List<T> toList(Set<T> set) {
        if (set == null) {
            return new ArrayList<>();
        }
        return new ArrayList<>(set);
    }
    
    /**
     * 获取集合的第一个元素
     */
    public static <T> T getFirst(List<T> list) {
        if (isEmpty(list)) {
            return null;
        }
        return list.get(0);
    }
    
    /**
     * 获取集合的最后一个元素
     */
    public static <T> T getLast(List<T> list) {
        if (isEmpty(list)) {
            return null;
        }
        return list.get(list.size() - 1);
    }
    
    /**
     * 反转列表
     */
    public static <T> List<T> reverse(List<T> list) {
        if (isEmpty(list)) {
            return new ArrayList<>();
        }
        List<T> reversed = new ArrayList<>(list);
        Collections.reverse(reversed);
        return reversed;
    }
    
    /**
     * 对列表进行排序
     */
    public static <T extends Comparable<? super T>> List<T> sort(List<T> list) {
        if (isEmpty(list)) {
            return new ArrayList<>();
        }
        List<T> sorted = new ArrayList<>(list);
        Collections.sort(sorted);
        return sorted;
    }
    
    /**
     * 根据指定字段去重
     */
    public static <T, K> List<T> distinctByKey(List<T> list, Function<? super T, K> keyExtractor) {
        if (isEmpty(list)) {
            return new ArrayList<>();
        }
        
        Map<K, T> map = new LinkedHashMap<>();
        for (T item : list) {
            K key = keyExtractor.apply(item);
            map.putIfAbsent(key, item);
        }
        return new ArrayList<>(map.values());
    }
    
    /**
     * 将List按照指定大小分割
     */
    public static <T> List<List<T>> splitList(List<T> list, int size) {
        if (isEmpty(list) || size <= 0) {
            return new ArrayList<>();
        }
        
        List<List<T>> result = new ArrayList<>();
        for (int i = 0; i < list.size(); i += size) {
            int end = Math.min(i + size, list.size());
            result.add(list.subList(i, end));
        }
        return result;
    }
    
    /**
     * 将List转换为Map
     */
    public static <T, K, V> Map<K, V> toMap(List<T> list, Function<? super T, K> keyExtractor, Function<? super T, V> valueExtractor) {
        if (isEmpty(list)) {
            return new HashMap<>();
        }
        
        Map<K, V> map = new HashMap<>();
        for (T item : list) {
            K key = keyExtractor.apply(item);
            V value = valueExtractor.apply(item);
            map.put(key, value);
        }
        return map;
    }
    
    /**
     * 统计集合中元素的出现次数
     */
    public static <T> Map<T, Long> countOccurrences(List<T> list) {
        if (isEmpty(list)) {
            return new HashMap<>();
        }
        return list.stream().collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));
    }
    
    /**
     * 获取集合中不重复的元素
     */
    public static <T> List<T> getUniqueElements(List<T> list) {
        if (isEmpty(list)) {
            return new ArrayList<>();
        }
        return list.stream().distinct().collect(Collectors.toList());
    }
    
    /**
     * 合并多个集合
     */
    @SafeVarargs
    public static <T> List<T> merge(List<T>... lists) {
        List<T> result = new ArrayList<>();
        if (lists != null) {
            for (List<T> list : lists) {
                if (isNotEmpty(list)) {
                    result.addAll(list);
                }
            }
        }
        return result;
    }
    
    private CollectionUtils() {
        // 私有构造函数，防止实例化
    }
}